// Sington
// 单例模式
#include <iostream>
#include <string>

using namespace std;

class Sington
{
private:
    // 构造函数私有
    Sington() {
        cout << "构造函数" << endl;
    }
    static Sington* instance;
public:
    ~Sington() {
    }
    // 静态方法 全局唯一访问点
    static Sington* getInstance() {
        if(instance == nullptr)
        {
            // 静态变量只有一份全局唯一
            // 第一次调用创建对象
            // 懒汉式 创建对象延时了
            instance = new Sington();
        }
        return instance;
    }

};
// 静态变量初始化
Sington* Sington::instance = nullptr;

class Singleton
{
private:
    // 1 构造函数私有化
    Singleton() {
        // 初始化大量的资源
    }
    // 拷贝
    Singleton(const Singleton &s) = delete;
    // 赋值(运算符重载)
    // =
    Singleton& operator=(const Singleton & rhs) = delete;

public:
    // 2 
    static Singleton* getInstance() {
        // 互斥锁
        // 多线程不安全，所以要加互斥锁
        // 懒汉式
        static Singleton* instance = new Singleton();
        // 互斥锁
        return instance;
    }
    ~Singleton() {}
};

class Point
{
private:
    int _x;
    int _y;
public:
    Point(int x, int y) 
    :_x(x), _y(y)
    {}
    ~Point() {}
    // +
    Point* operator+ (const Point &rhs)
    {
        return new Point(_x + rhs._x, _y + rhs._y);
    }
    void show() {
        cout << "x=" << _x << "," << "y=" << _y << endl;
    }
};
int main(int argc, char const *argv[])
{
    // 运算符重载
    // + 数值：算数运算
    // + 字符串 拼接
    // + object:自己定义，运算符重载
    

    // Sington *s1 = Sington::getInstance();
    // Sington *s2 = Sington::getInstance();

    // cout << s1 << endl;
    // cout << s2 << endl;
    Point p1(3, 4);
    Point p2(5, 6);
    Point* p3 = p1+p2;
    p3->show();

    return 0;
}
